// <copyright file="ElementMaster.cs" company="Largo">
// Copyright (c) 2009 All Right Reserved
// </copyright>
// <author> vl </author>
// <email></email>
// <date>2009-02-01</date>
// <summary></summary>

using System.Collections.Generic;
using System.Linq;
using LargoCommon.Abstract;

namespace LargoCommon.Music
{
    /// <summary>
    /// Element Master
    /// </summary>
    public class ElementMaster {
        #region Constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="ElementMaster" /> class.
        /// </summary>
        /// <param name="givenList">The given list.</param>
        public ElementMaster(IEnumerable<MusicalElement> givenList) {
            this.List = givenList;
        }
        #endregion

        #region Public properties
        /// <summary>
        /// Gets or sets the list.
        /// </summary>
        /// <value>
        /// The list.
        /// </value>
        public IEnumerable<MusicalElement> List { get; set; }
        #endregion

        #region String representation
        /// <summary> String representation of the object. </summary>
        /// <returns> Returns value. </returns>
        public override string ToString() {
            return "Element Master";
        }
        #endregion

        #region Public methods
        /// <summary>
        /// Sets the random rhythm.
        /// </summary>
        /// <param name="rhythmicStructures">The rhythmic structures.</param>
        public void SetRandomRhythm(IList<RhythmicStructure> rhythmicStructures) {
            var cnt = rhythmicStructures.Count;
            foreach (var element1 in this.List) {
                if (element1 == null) {
                    continue;
                }

                var i = 0;
                RhythmicStructure rstruct;
                while (true) {
                    var idx = MathSupport.RandomNatural(cnt);
                    rstruct = rhythmicStructures[idx];
                    if (rstruct.Level > 0 || i > 10) {
                        break;
                    }

                    i++;
                }

                element1.Status.RhythmicStructure = rstruct;
            }
        }

        /// <summary>
        /// Reorders the line rhythmic.
        /// </summary>
        public void ReorderRhythmic() {
            foreach (var element1 in this.List) {
                if (element1?.Status.RhythmicStructure == null) {
                    continue;
                }

                foreach (var element2 in this.List) {
                    if (element2?.Status.RhythmicStructure == null || element2.Bar.BarNumber <= element1.Bar.BarNumber) {
                        continue;
                    }

                    //// Random Effect
                    //// if (MathSupport.RandomNatural(10) >= 3) {
                    ////     continue;
                    //// }

                    var rhythmicStructure = element2.Status.RhythmicStructure;
                    element2.Status.RhythmicStructure = element1.Status.RhythmicStructure;
                    element1.Status.RhythmicStructure = rhythmicStructure;
                }
            }
        }

        /// <summary>
        /// Reorders the line melodic.
        /// </summary>
        public void ReorderMelodic() {
            foreach (var element1 in this.List) {
                if (element1?.Status.RhythmicStructure == null) {
                    continue;
                }

                var element1C = element1;
                foreach (var element2 in this.List.Where(element2 => element2.Status.RhythmicStructure != null && element2.Bar.BarNumber > element1C.Bar.BarNumber).Where(element2 => MathSupport.RandomNatural(10) < 3)) {
                        element1.SwapMelodicWith(element2);
                }
            }
        }
        #endregion

        /// <summary>
        /// Converts to melodic.
        /// </summary>
        /// <param name="givenChannel">The given channel.</param>
        public void ConvertToMelodic(MidiChannel givenChannel) {
            foreach (var elem in this.List) {
                elem.Status.LineType = MusicalLineType.Melodic;
                elem.Status.Instrument =
                    new MusicalInstrument(MidiMelodicInstrument.NylonAcousticGuitar); //// AcousticGrandPiano
                elem.Status.MelodicShape = MelodicShape.Scales;
                elem.Status.Octave = MusicalOctave.OneLine;
                elem.Status.MelodicGenus = MelodicGenus.Melodic;
                elem.Status.MelodicFunction = MelodicFunction.HarmonicMotion;
                //// elem.Status.Channel = givenChannel;
                elem.Status.LocalPurpose = LinePurpose.Composed;
                elem.Tones = new MusicalStrikeCollection();
            }
        }

        /// <summary>
        /// Converts to rhythmic.
        /// </summary>
        /// <param name="givenChannel">The given channel.</param>
        public void ConvertToRhythmic(MidiChannel givenChannel) {
            foreach (var elem in this.List) {
                elem.Status.LineType = MusicalLineType.Rhythmic;
                elem.Status.Instrument =
                    new MusicalInstrument(MidiRhythmicInstrument.AcousticSnare);
                elem.Status.MelodicShape = MelodicShape.None;
                elem.Status.Octave = MusicalOctave.None;
                elem.Status.MelodicGenus = MelodicGenus.None;
                elem.Status.MelodicFunction = MelodicFunction.None;
                //// elem.Status.Channel = givenChannel;
                elem.Status.LocalPurpose = LinePurpose.Composed;
                elem.Tones = new MusicalStrikeCollection();
            }
        }

        /// <summary>
        /// Eliminates the melodic dependencies.
        /// </summary>
        public void EliminateMelodicDependencies() {
            foreach (var element in this.List) {
                if (element.Status.OriginalMelodicPoint.IsDefined) {
                    element.Status.LocalPurpose = LinePurpose.Mute;
                    element.Status.LineType = MusicalLineType.None;
                    element.Tones = new MusicalStrikeCollection();
                }
            }
        }

        /// <summary>
        /// Eliminates the rhythmic dependencies.
        /// </summary>
        public void EliminateRhythmicDependencies() {
            foreach (var element in this.List) {
                if (element.Status.OriginalRhythmicPoint.IsDefined) {
                    element.Status.LocalPurpose = LinePurpose.Mute;
                    element.Status.LineType = MusicalLineType.None;
                    element.Tones = new MusicalStrikeCollection();
                }
            }
        }

        /// <summary>
        /// Haves any purpose.
        /// </summary>
        /// <returns>
        /// Returns value.
        /// </returns>
        public bool HaveAnyPurpose() {
            bool isEmpty = true;
            foreach (var element in this.List) {
                if (element.Status.LocalPurpose == LinePurpose.Mute || element.Status.LocalPurpose == LinePurpose.None) {
                    continue;
                }

                isEmpty = false;
            }

            return !isEmpty;
        }
    }
}